package com.warm.pump.module.sys.dao.gen;

import java.util.List;
import java.util.Map;
import java.util.Date;
import java.math.BigDecimal;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import com.warm.pump.frame.gen.bean.PageBean;
import com.warm.pump.frame.gen.util.TypeCast;
import com.warm.pump.frame.gen.exception.ServiceException;
import com.warm.pump.module.sys.bean.po.gen.DictDyna;
import com.warm.pump.module.sys.mapper.gen.DictDynaMapper;
import com.warm.pump.module.sys.bean.po.gen.DictDynaExample;
@Repository
public class DictDynaDao {
	// 日志对象
	private transient Log log = LogFactory.getLog(this.getClass());
	@Autowired
	private DictDynaMapper dictDynaMapper;

	// 增加一个后台DictDyna表
	
	public boolean insert(DictDyna dictDyna) {
		try {
			dictDynaMapper.insert(dictDyna);
			log.debug("后台DictDyna表增加成功");
			return true;
		} catch (Exception e) {
			log.debug("后台DictDyna表增加失败");
			throw new ServiceException("后台DictDyna表增加失败",e);
		}
	}
	// 增加一个后台DictDyna表Selective
	
	public boolean insertSelective(DictDyna dictDyna) {
		try {
			dictDynaMapper.insertSelective(dictDyna);
			log.debug("后台DictDyna表增加成功");
			return true;
		} catch (Exception e) {
			log.debug("后台DictDyna表增加失败");
			throw new ServiceException("后台DictDyna表增加失败",e);
		}
	}

	// 删除一个后台DictDyna表
	
	public boolean deleteByPrimaryKey(Long id) {
		try{
			dictDynaMapper.deleteByPrimaryKey(id);
			log.debug("后台DictDyna表删除成功");
			return true;
		} catch(Exception e){
			log.debug("后台DictDyna表删除失败");
			throw new ServiceException("后台DictDyna表删除失败",e);
		}
	}
	// 删除一个后台DictDyna表byMap
	
	public boolean deleteByMap(Map dictDynaMap) {
		try{
			dictDynaMapper.deleteByExample(createDictDynaExample(dictDynaMap,null,null));
			log.debug("后台DictDyna根据Map删除成功");
			return true;
		}
		
		catch(Exception e){
			log.debug("后台DictDyna根据GroupID删除失败");
			throw new ServiceException("后台DictDyna根据object删除失败",e);
		}
	}
	// 修改一个后台DictDyna表
	
	public boolean updateByPrimaryKey(DictDyna dictDyna) {
		try{
			dictDynaMapper.updateByPrimaryKey(dictDyna);
			log.debug("后台DictDyna表修改成功");
			return true;
		}
		
		catch(Exception e){
			log.debug("后台DictDyna表修改失败");
			throw new ServiceException("后台DictDyna表修改失败",e);
		}
	}
	// 修改一个后台DictDyna表Selective
	
	public boolean updateByPrimaryKeySelective(DictDyna dictDyna) {
		try{
			dictDynaMapper.updateByPrimaryKeySelective(dictDyna);
			log.debug("后台DictDyna表修改成功");
			return true;
		}
		
		catch(Exception e){
			log.debug("后台DictDyna表修改失败");
			throw new ServiceException("后台DictDyna表修改失败",e);
		}
	}
	// 修改一个后台DictDyna表
	
	public boolean updateByMap(DictDyna dictDyna,Map dictDynaMap) {
		try{
			dictDynaMapper.updateByExample(dictDyna,createDictDynaExample(dictDynaMap,null,null));
			log.debug("后台批量DictDyna表修改成功");
			return true;
		}
		catch(Exception e){
			log.debug("后台批量DictDyna表修改失败");
			throw new ServiceException("后台DictDyna表批量修改失败",e);
		}
	}
	// 修改一个后台DictDyna表Selective
	
	public boolean updateByMapSelective(DictDyna dictDyna,Map dictDynaMap) {
		try{
			dictDynaMapper.updateByExampleSelective(dictDyna,createDictDynaExample(dictDynaMap,null,null));
			log.debug("后台批量DictDyna表修改成功");
			return true;
		}
		catch(Exception e){
			log.debug("后台批量DictDyna表修改失败");
			throw new ServiceException("后台DictDyna表批量修改失败",e);
		}
	}

	// 查询一个后台DictDyna表
	
	public DictDyna selectByPrimaryKey(Long id) {
		return dictDynaMapper.selectByPrimaryKey(id);
	}
	
	// 查询一个后台DictDyna表-根据map
	
	public DictDyna selectByMap(Map dictDynaMap) {
		List<DictDyna> list = getListByMap(dictDynaMap);
		if(list==null||list.isEmpty()){
			return null;
		}else{
			return list.get(0);
		}
	}

	////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 查询所有后台DictDyna表
	
	public List<DictDyna> getListByMap(Map dictDynaMap) {
		
		return dictDynaMapper.selectByExample(createDictDynaExample(dictDynaMap,null,null));
	}

	//统计后台DictDyna表数量
	
	public int countTotalByMap(Map dictDynaMap) {
		
		return dictDynaMapper.countByExample(createDictDynaExample(dictDynaMap,null,null));
	}

	
	public List<DictDyna> getListByMapPage(Map dictDynaMap, int limitStart,
			int limitOffset) {
		
		return dictDynaMapper.selectByExample(createDictDynaExample(dictDynaMap,limitStart,limitOffset));
	}
	
	
	public PageBean getPageBeanByMap(Map dictDynaMap,int pageNo,int pageSize) {
		Integer count = countTotalByMap(dictDynaMap);
		PageBean pageBean = new PageBean();
		pageBean.setCount(count);
		pageBean.setPageNo(pageNo);
		pageBean.setPageSize(pageSize);
		int limitStart = pageBean.getStartNo();
		int limitOffset = pageSize;
		pageBean.setData(dictDynaMapper.selectByExample(createDictDynaExample(dictDynaMap,limitStart,limitOffset)));
		return pageBean;
	}
		
	private DictDynaExample createDictDynaExample(Map dictDynaMap,Integer limitStart,Integer limitOffset){
			DictDynaExample dictDynaEx = new DictDynaExample();
			DictDynaExample.Criteria c = dictDynaEx.createCriteria();
				Long id_null = TypeCast.getLong(dictDynaMap.get("id_null"));
				Long id_notNull = TypeCast.getLong(dictDynaMap.get("id_notNull"));
				Long id = TypeCast.getLong(dictDynaMap.get("id"));
				Long id_not = TypeCast.getLong(dictDynaMap.get("id_not"));
				Long id_greater = TypeCast.getLong(dictDynaMap.get("id_greater"));
				Long id_greaterEqual = TypeCast.getLong(dictDynaMap.get("id_greaterEqual"));
				Long id_less = TypeCast.getLong(dictDynaMap.get("id_less"));
				Long id_lessEqual = TypeCast.getLong(dictDynaMap.get("id_lessEqual"));
				List<Long> id_in = TypeCast.getLongList(dictDynaMap.get("id_in"));
				List<Long> id_notIn = TypeCast.getLongList(dictDynaMap.get("id_notIn"));
				Long id_between1 = TypeCast.getLong(dictDynaMap.get("id_between1"));
				Long id_between2 = TypeCast.getLong(dictDynaMap.get("id_between2"));
				Long id_notBetween1 = TypeCast.getLong(dictDynaMap.get("id_notBetween1"));
				Long id_notBetween2 = TypeCast.getLong(dictDynaMap.get("id_notBetween2"));
				
				if(id_null != null){
					c.andIdIsNull();
				}
				if(id_notNull != null){
					c.andIdIsNotNull();
				}
				if(id != null){
					c.andIdEqualTo(id);
				}
				if(id_not != null){
					c.andIdNotEqualTo(id_not);
				}
				if(id_greater != null){
					c.andIdGreaterThan(id_greater);
				}
				if(id_greaterEqual != null){
					c.andIdGreaterThanOrEqualTo(id_greaterEqual);
				}
				if(id_less != null){
					c.andIdLessThan(id_less);
				}
				if(id_lessEqual != null){
					c.andIdLessThanOrEqualTo(id_lessEqual);
				}
				if(id_in != null){
					c.andIdIn(id_in);
				}
				if(id_notIn != null){
					c.andIdNotIn(id_notIn);
				}
				if(id_between1 != null){
					c.andIdBetween(id_between1,id_between2);
				}
				if(id_notBetween1 != null){
					c.andIdNotBetween(id_notBetween1,id_notBetween2);
				}
				String groupCode_null = TypeCast.getString(dictDynaMap.get("groupCode_null"));
				String groupCode_notNull = TypeCast.getString(dictDynaMap.get("groupCode_notNull"));
				String groupCode = TypeCast.getString(dictDynaMap.get("groupCode"));
				String groupCode_not = TypeCast.getString(dictDynaMap.get("groupCode_not"));
				String groupCode_greater = TypeCast.getString(dictDynaMap.get("groupCode_greater"));
				String groupCode_greaterEqual = TypeCast.getString(dictDynaMap.get("groupCode_greaterEqual"));
				String groupCode_less = TypeCast.getString(dictDynaMap.get("groupCode_less"));
				String groupCode_lessEqual = TypeCast.getString(dictDynaMap.get("groupCode_lessEqual"));
				String groupCode_like = TypeCast.getString(dictDynaMap.get("groupCode_like"));
				String groupCode_notLike = TypeCast.getString(dictDynaMap.get("groupCode_notLike"));
				List<String> groupCode_in = TypeCast.getStringList(dictDynaMap.get("groupCode_in"));
				List<String> groupCode_notIn = TypeCast.getStringList(dictDynaMap.get("groupCode_notIn"));
				String groupCode_between1 = TypeCast.getString(dictDynaMap.get("groupCode_between1"));
				String groupCode_between2 = TypeCast.getString(dictDynaMap.get("groupCode_between2"));
				String groupCode_notBetween1 = TypeCast.getString(dictDynaMap.get("groupCode_notBetween1"));
				String groupCode_notBetween2 = TypeCast.getString(dictDynaMap.get("groupCode_notBetween2"));
				
				if(groupCode_null != null){
					c.andGroupCodeIsNull();
				}
				if(groupCode_notNull != null){
					c.andGroupCodeIsNotNull();
				}
				if(groupCode != null){
					c.andGroupCodeEqualTo(groupCode);
				}
				if(groupCode_not != null){
					c.andGroupCodeNotEqualTo(groupCode_not);
				}
				if(groupCode_greater != null){
					c.andGroupCodeGreaterThan(groupCode_greater);
				}
				if(groupCode_greaterEqual != null){
					c.andGroupCodeGreaterThanOrEqualTo(groupCode_greaterEqual);
				}
				if(groupCode_less != null){
					c.andGroupCodeLessThan(groupCode_less);
				}
				if(groupCode_lessEqual != null){
					c.andGroupCodeLessThanOrEqualTo(groupCode_lessEqual);
				}
				if(groupCode_like != null){
					c.andGroupCodeLike(groupCode_like);
				}
				if(groupCode_notLike != null){
					c.andGroupCodeNotLike(groupCode_notLike);
				}
				if(groupCode_in != null){
					c.andGroupCodeIn(groupCode_in);
				}
				if(groupCode_notIn != null){
					c.andGroupCodeNotIn(groupCode_notIn);
				}
				if(groupCode_between1 != null){
					c.andGroupCodeBetween(groupCode_between1,groupCode_between2);
				}
				if(groupCode_notBetween1 != null){
					c.andGroupCodeNotBetween(groupCode_notBetween1,groupCode_notBetween2);
				}
				String groupName_null = TypeCast.getString(dictDynaMap.get("groupName_null"));
				String groupName_notNull = TypeCast.getString(dictDynaMap.get("groupName_notNull"));
				String groupName = TypeCast.getString(dictDynaMap.get("groupName"));
				String groupName_not = TypeCast.getString(dictDynaMap.get("groupName_not"));
				String groupName_greater = TypeCast.getString(dictDynaMap.get("groupName_greater"));
				String groupName_greaterEqual = TypeCast.getString(dictDynaMap.get("groupName_greaterEqual"));
				String groupName_less = TypeCast.getString(dictDynaMap.get("groupName_less"));
				String groupName_lessEqual = TypeCast.getString(dictDynaMap.get("groupName_lessEqual"));
				String groupName_like = TypeCast.getString(dictDynaMap.get("groupName_like"));
				String groupName_notLike = TypeCast.getString(dictDynaMap.get("groupName_notLike"));
				List<String> groupName_in = TypeCast.getStringList(dictDynaMap.get("groupName_in"));
				List<String> groupName_notIn = TypeCast.getStringList(dictDynaMap.get("groupName_notIn"));
				String groupName_between1 = TypeCast.getString(dictDynaMap.get("groupName_between1"));
				String groupName_between2 = TypeCast.getString(dictDynaMap.get("groupName_between2"));
				String groupName_notBetween1 = TypeCast.getString(dictDynaMap.get("groupName_notBetween1"));
				String groupName_notBetween2 = TypeCast.getString(dictDynaMap.get("groupName_notBetween2"));
				
				if(groupName_null != null){
					c.andGroupNameIsNull();
				}
				if(groupName_notNull != null){
					c.andGroupNameIsNotNull();
				}
				if(groupName != null){
					c.andGroupNameEqualTo(groupName);
				}
				if(groupName_not != null){
					c.andGroupNameNotEqualTo(groupName_not);
				}
				if(groupName_greater != null){
					c.andGroupNameGreaterThan(groupName_greater);
				}
				if(groupName_greaterEqual != null){
					c.andGroupNameGreaterThanOrEqualTo(groupName_greaterEqual);
				}
				if(groupName_less != null){
					c.andGroupNameLessThan(groupName_less);
				}
				if(groupName_lessEqual != null){
					c.andGroupNameLessThanOrEqualTo(groupName_lessEqual);
				}
				if(groupName_like != null){
					c.andGroupNameLike(groupName_like);
				}
				if(groupName_notLike != null){
					c.andGroupNameNotLike(groupName_notLike);
				}
				if(groupName_in != null){
					c.andGroupNameIn(groupName_in);
				}
				if(groupName_notIn != null){
					c.andGroupNameNotIn(groupName_notIn);
				}
				if(groupName_between1 != null){
					c.andGroupNameBetween(groupName_between1,groupName_between2);
				}
				if(groupName_notBetween1 != null){
					c.andGroupNameNotBetween(groupName_notBetween1,groupName_notBetween2);
				}
				Integer type_null = TypeCast.getInteger(dictDynaMap.get("type_null"));
				Integer type_notNull = TypeCast.getInteger(dictDynaMap.get("type_notNull"));
				Integer type = TypeCast.getInteger(dictDynaMap.get("type"));
				Integer type_not = TypeCast.getInteger(dictDynaMap.get("type_not"));
				Integer type_greater = TypeCast.getInteger(dictDynaMap.get("type_greater"));
				Integer type_greaterEqual = TypeCast.getInteger(dictDynaMap.get("type_greaterEqual"));
				Integer type_less = TypeCast.getInteger(dictDynaMap.get("type_less"));
				Integer type_lessEqual = TypeCast.getInteger(dictDynaMap.get("type_lessEqual"));
				List<Integer> type_in = TypeCast.getIntegerList(dictDynaMap.get("type_in"));
				List<Integer> type_notIn = TypeCast.getIntegerList(dictDynaMap.get("type_notIn"));
				Integer type_between1 = TypeCast.getInteger(dictDynaMap.get("type_between1"));
				Integer type_between2 = TypeCast.getInteger(dictDynaMap.get("type_between2"));
				Integer type_notBetween1 = TypeCast.getInteger(dictDynaMap.get("type_notBetween1"));
				Integer type_notBetween2 = TypeCast.getInteger(dictDynaMap.get("type_notBetween2"));
				
				if(type_null != null){
					c.andTypeIsNull();
				}
				if(type_notNull != null){
					c.andTypeIsNotNull();
				}
				if(type != null){
					c.andTypeEqualTo(type);
				}
				if(type_not != null){
					c.andTypeNotEqualTo(type_not);
				}
				if(type_greater != null){
					c.andTypeGreaterThan(type_greater);
				}
				if(type_greaterEqual != null){
					c.andTypeGreaterThanOrEqualTo(type_greaterEqual);
				}
				if(type_less != null){
					c.andTypeLessThan(type_less);
				}
				if(type_lessEqual != null){
					c.andTypeLessThanOrEqualTo(type_lessEqual);
				}
				if(type_in != null){
					c.andTypeIn(type_in);
				}
				if(type_notIn != null){
					c.andTypeNotIn(type_notIn);
				}
				if(type_between1 != null){
					c.andTypeBetween(type_between1,type_between2);
				}
				if(type_notBetween1 != null){
					c.andTypeNotBetween(type_notBetween1,type_notBetween2);
				}
				String dictTxt_null = TypeCast.getString(dictDynaMap.get("dictTxt_null"));
				String dictTxt_notNull = TypeCast.getString(dictDynaMap.get("dictTxt_notNull"));
				String dictTxt = TypeCast.getString(dictDynaMap.get("dictTxt"));
				String dictTxt_not = TypeCast.getString(dictDynaMap.get("dictTxt_not"));
				String dictTxt_greater = TypeCast.getString(dictDynaMap.get("dictTxt_greater"));
				String dictTxt_greaterEqual = TypeCast.getString(dictDynaMap.get("dictTxt_greaterEqual"));
				String dictTxt_less = TypeCast.getString(dictDynaMap.get("dictTxt_less"));
				String dictTxt_lessEqual = TypeCast.getString(dictDynaMap.get("dictTxt_lessEqual"));
				String dictTxt_like = TypeCast.getString(dictDynaMap.get("dictTxt_like"));
				String dictTxt_notLike = TypeCast.getString(dictDynaMap.get("dictTxt_notLike"));
				List<String> dictTxt_in = TypeCast.getStringList(dictDynaMap.get("dictTxt_in"));
				List<String> dictTxt_notIn = TypeCast.getStringList(dictDynaMap.get("dictTxt_notIn"));
				String dictTxt_between1 = TypeCast.getString(dictDynaMap.get("dictTxt_between1"));
				String dictTxt_between2 = TypeCast.getString(dictDynaMap.get("dictTxt_between2"));
				String dictTxt_notBetween1 = TypeCast.getString(dictDynaMap.get("dictTxt_notBetween1"));
				String dictTxt_notBetween2 = TypeCast.getString(dictDynaMap.get("dictTxt_notBetween2"));
				
				if(dictTxt_null != null){
					c.andDictTxtIsNull();
				}
				if(dictTxt_notNull != null){
					c.andDictTxtIsNotNull();
				}
				if(dictTxt != null){
					c.andDictTxtEqualTo(dictTxt);
				}
				if(dictTxt_not != null){
					c.andDictTxtNotEqualTo(dictTxt_not);
				}
				if(dictTxt_greater != null){
					c.andDictTxtGreaterThan(dictTxt_greater);
				}
				if(dictTxt_greaterEqual != null){
					c.andDictTxtGreaterThanOrEqualTo(dictTxt_greaterEqual);
				}
				if(dictTxt_less != null){
					c.andDictTxtLessThan(dictTxt_less);
				}
				if(dictTxt_lessEqual != null){
					c.andDictTxtLessThanOrEqualTo(dictTxt_lessEqual);
				}
				if(dictTxt_like != null){
					c.andDictTxtLike(dictTxt_like);
				}
				if(dictTxt_notLike != null){
					c.andDictTxtNotLike(dictTxt_notLike);
				}
				if(dictTxt_in != null){
					c.andDictTxtIn(dictTxt_in);
				}
				if(dictTxt_notIn != null){
					c.andDictTxtNotIn(dictTxt_notIn);
				}
				if(dictTxt_between1 != null){
					c.andDictTxtBetween(dictTxt_between1,dictTxt_between2);
				}
				if(dictTxt_notBetween1 != null){
					c.andDictTxtNotBetween(dictTxt_notBetween1,dictTxt_notBetween2);
				}
				String status_null = TypeCast.getString(dictDynaMap.get("status_null"));
				String status_notNull = TypeCast.getString(dictDynaMap.get("status_notNull"));
				String status = TypeCast.getString(dictDynaMap.get("status"));
				String status_not = TypeCast.getString(dictDynaMap.get("status_not"));
				String status_greater = TypeCast.getString(dictDynaMap.get("status_greater"));
				String status_greaterEqual = TypeCast.getString(dictDynaMap.get("status_greaterEqual"));
				String status_less = TypeCast.getString(dictDynaMap.get("status_less"));
				String status_lessEqual = TypeCast.getString(dictDynaMap.get("status_lessEqual"));
				String status_like = TypeCast.getString(dictDynaMap.get("status_like"));
				String status_notLike = TypeCast.getString(dictDynaMap.get("status_notLike"));
				List<String> status_in = TypeCast.getStringList(dictDynaMap.get("status_in"));
				List<String> status_notIn = TypeCast.getStringList(dictDynaMap.get("status_notIn"));
				String status_between1 = TypeCast.getString(dictDynaMap.get("status_between1"));
				String status_between2 = TypeCast.getString(dictDynaMap.get("status_between2"));
				String status_notBetween1 = TypeCast.getString(dictDynaMap.get("status_notBetween1"));
				String status_notBetween2 = TypeCast.getString(dictDynaMap.get("status_notBetween2"));
				
				if(status_null != null){
					c.andStatusIsNull();
				}
				if(status_notNull != null){
					c.andStatusIsNotNull();
				}
				if(status != null){
					c.andStatusEqualTo(status);
				}
				if(status_not != null){
					c.andStatusNotEqualTo(status_not);
				}
				if(status_greater != null){
					c.andStatusGreaterThan(status_greater);
				}
				if(status_greaterEqual != null){
					c.andStatusGreaterThanOrEqualTo(status_greaterEqual);
				}
				if(status_less != null){
					c.andStatusLessThan(status_less);
				}
				if(status_lessEqual != null){
					c.andStatusLessThanOrEqualTo(status_lessEqual);
				}
				if(status_like != null){
					c.andStatusLike(status_like);
				}
				if(status_notLike != null){
					c.andStatusNotLike(status_notLike);
				}
				if(status_in != null){
					c.andStatusIn(status_in);
				}
				if(status_notIn != null){
					c.andStatusNotIn(status_notIn);
				}
				if(status_between1 != null){
					c.andStatusBetween(status_between1,status_between2);
				}
				if(status_notBetween1 != null){
					c.andStatusNotBetween(status_notBetween1,status_notBetween2);
				}
				Date statusTime_null = TypeCast.getDate(dictDynaMap.get("statusTime_null"));
				Date statusTime_notNull = TypeCast.getDate(dictDynaMap.get("statusTime_notNull"));
				Date statusTime = TypeCast.getDate(dictDynaMap.get("statusTime"));
				Date statusTime_not = TypeCast.getDate(dictDynaMap.get("statusTime_not"));
				Date statusTime_greater = TypeCast.getDate(dictDynaMap.get("statusTime_greater"));
				Date statusTime_greaterEqual = TypeCast.getDate(dictDynaMap.get("statusTime_greaterEqual"));
				Date statusTime_less = TypeCast.getDate(dictDynaMap.get("statusTime_less"));
				Date statusTime_lessEqual = TypeCast.getDate(dictDynaMap.get("statusTime_lessEqual"));
				List<Date> statusTime_in = TypeCast.getDateList(dictDynaMap.get("statusTime_in"));
				List<Date> statusTime_notIn = TypeCast.getDateList(dictDynaMap.get("statusTime_notIn"));
				Date statusTime_between1 = TypeCast.getDate(dictDynaMap.get("statusTime_between1"));
				Date statusTime_between2 = TypeCast.getDate(dictDynaMap.get("statusTime_between2"));
				Date statusTime_notBetween1 = TypeCast.getDate(dictDynaMap.get("statusTime_notBetween1"));
				Date statusTime_notBetween2 = TypeCast.getDate(dictDynaMap.get("statusTime_notBetween2"));
				
				if(statusTime_null != null){
					c.andStatusTimeIsNull();
				}
				if(statusTime_notNull != null){
					c.andStatusTimeIsNotNull();
				}
				if(statusTime != null){
					c.andStatusTimeEqualTo(statusTime);
				}
				if(statusTime_not != null){
					c.andStatusTimeNotEqualTo(statusTime_not);
				}
				if(statusTime_greater != null){
					c.andStatusTimeGreaterThan(statusTime_greater);
				}
				if(statusTime_greaterEqual != null){
					c.andStatusTimeGreaterThanOrEqualTo(statusTime_greaterEqual);
				}
				if(statusTime_less != null){
					c.andStatusTimeLessThan(statusTime_less);
				}
				if(statusTime_lessEqual != null){
					c.andStatusTimeLessThanOrEqualTo(statusTime_lessEqual);
				}
				if(statusTime_in != null){
					c.andStatusTimeIn(statusTime_in);
				}
				if(statusTime_notIn != null){
					c.andStatusTimeNotIn(statusTime_notIn);
				}
				if(statusTime_between1 != null){
					c.andStatusTimeBetween(statusTime_between1,statusTime_between2);
				}
				if(statusTime_notBetween1 != null){
					c.andStatusTimeNotBetween(statusTime_notBetween1,statusTime_notBetween2);
				}
				Integer isSys_null = TypeCast.getInteger(dictDynaMap.get("isSys_null"));
				Integer isSys_notNull = TypeCast.getInteger(dictDynaMap.get("isSys_notNull"));
				Integer isSys = TypeCast.getInteger(dictDynaMap.get("isSys"));
				Integer isSys_not = TypeCast.getInteger(dictDynaMap.get("isSys_not"));
				Integer isSys_greater = TypeCast.getInteger(dictDynaMap.get("isSys_greater"));
				Integer isSys_greaterEqual = TypeCast.getInteger(dictDynaMap.get("isSys_greaterEqual"));
				Integer isSys_less = TypeCast.getInteger(dictDynaMap.get("isSys_less"));
				Integer isSys_lessEqual = TypeCast.getInteger(dictDynaMap.get("isSys_lessEqual"));
				List<Integer> isSys_in = TypeCast.getIntegerList(dictDynaMap.get("isSys_in"));
				List<Integer> isSys_notIn = TypeCast.getIntegerList(dictDynaMap.get("isSys_notIn"));
				Integer isSys_between1 = TypeCast.getInteger(dictDynaMap.get("isSys_between1"));
				Integer isSys_between2 = TypeCast.getInteger(dictDynaMap.get("isSys_between2"));
				Integer isSys_notBetween1 = TypeCast.getInteger(dictDynaMap.get("isSys_notBetween1"));
				Integer isSys_notBetween2 = TypeCast.getInteger(dictDynaMap.get("isSys_notBetween2"));
				
				if(isSys_null != null){
					c.andIsSysIsNull();
				}
				if(isSys_notNull != null){
					c.andIsSysIsNotNull();
				}
				if(isSys != null){
					c.andIsSysEqualTo(isSys);
				}
				if(isSys_not != null){
					c.andIsSysNotEqualTo(isSys_not);
				}
				if(isSys_greater != null){
					c.andIsSysGreaterThan(isSys_greater);
				}
				if(isSys_greaterEqual != null){
					c.andIsSysGreaterThanOrEqualTo(isSys_greaterEqual);
				}
				if(isSys_less != null){
					c.andIsSysLessThan(isSys_less);
				}
				if(isSys_lessEqual != null){
					c.andIsSysLessThanOrEqualTo(isSys_lessEqual);
				}
				if(isSys_in != null){
					c.andIsSysIn(isSys_in);
				}
				if(isSys_notIn != null){
					c.andIsSysNotIn(isSys_notIn);
				}
				if(isSys_between1 != null){
					c.andIsSysBetween(isSys_between1,isSys_between2);
				}
				if(isSys_notBetween1 != null){
					c.andIsSysNotBetween(isSys_notBetween1,isSys_notBetween2);
				}
				String remark_null = TypeCast.getString(dictDynaMap.get("remark_null"));
				String remark_notNull = TypeCast.getString(dictDynaMap.get("remark_notNull"));
				String remark = TypeCast.getString(dictDynaMap.get("remark"));
				String remark_not = TypeCast.getString(dictDynaMap.get("remark_not"));
				String remark_greater = TypeCast.getString(dictDynaMap.get("remark_greater"));
				String remark_greaterEqual = TypeCast.getString(dictDynaMap.get("remark_greaterEqual"));
				String remark_less = TypeCast.getString(dictDynaMap.get("remark_less"));
				String remark_lessEqual = TypeCast.getString(dictDynaMap.get("remark_lessEqual"));
				String remark_like = TypeCast.getString(dictDynaMap.get("remark_like"));
				String remark_notLike = TypeCast.getString(dictDynaMap.get("remark_notLike"));
				List<String> remark_in = TypeCast.getStringList(dictDynaMap.get("remark_in"));
				List<String> remark_notIn = TypeCast.getStringList(dictDynaMap.get("remark_notIn"));
				String remark_between1 = TypeCast.getString(dictDynaMap.get("remark_between1"));
				String remark_between2 = TypeCast.getString(dictDynaMap.get("remark_between2"));
				String remark_notBetween1 = TypeCast.getString(dictDynaMap.get("remark_notBetween1"));
				String remark_notBetween2 = TypeCast.getString(dictDynaMap.get("remark_notBetween2"));
				
				if(remark_null != null){
					c.andRemarkIsNull();
				}
				if(remark_notNull != null){
					c.andRemarkIsNotNull();
				}
				if(remark != null){
					c.andRemarkEqualTo(remark);
				}
				if(remark_not != null){
					c.andRemarkNotEqualTo(remark_not);
				}
				if(remark_greater != null){
					c.andRemarkGreaterThan(remark_greater);
				}
				if(remark_greaterEqual != null){
					c.andRemarkGreaterThanOrEqualTo(remark_greaterEqual);
				}
				if(remark_less != null){
					c.andRemarkLessThan(remark_less);
				}
				if(remark_lessEqual != null){
					c.andRemarkLessThanOrEqualTo(remark_lessEqual);
				}
				if(remark_like != null){
					c.andRemarkLike(remark_like);
				}
				if(remark_notLike != null){
					c.andRemarkNotLike(remark_notLike);
				}
				if(remark_in != null){
					c.andRemarkIn(remark_in);
				}
				if(remark_notIn != null){
					c.andRemarkNotIn(remark_notIn);
				}
				if(remark_between1 != null){
					c.andRemarkBetween(remark_between1,remark_between2);
				}
				if(remark_notBetween1 != null){
					c.andRemarkNotBetween(remark_notBetween1,remark_notBetween2);
				}
			if(dictDynaMap.get("orderBy")!=null){
				dictDynaEx.setOrderByClause((String)dictDynaMap.get("orderBy"));
			}
			if(limitStart != null && limitOffset != null){
				dictDynaEx.setLimitStart(limitStart);
				dictDynaEx.setLimitOffset(limitOffset);
			}
			
			return dictDynaEx;
	}
}
